home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / lib / lsb / init-functions
Text File  |  2008-09-16  |  10KB  |  366 lines
  1. # /lib/lsb/init-functions for Debian -*- shell-script -*-
  2. #
  3. #Copyright (c) 2002-08 Chris Lawrence
  4. #All rights reserved.
  5. #
  6. #Redistribution and use in source and binary forms, with or without
  7. #modification, are permitted provided that the following conditions
  8. #are met:
  9. #1. Redistributions of source code must retain the above copyright
  10. #   notice, this list of conditions and the following disclaimer.
  11. #2. Redistributions in binary form must reproduce the above copyright
  12. #   notice, this list of conditions and the following disclaimer in the
  13. #   documentation and/or other materials provided with the distribution.
  14. #3. Neither the name of the author nor the names of other contributors
  15. #   may be used to endorse or promote products derived from this software
  16. #   without specific prior written permission.
  17. #
  18. #THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19. #IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20. #WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21. #ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
  22. #LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23. #CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24. #SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  25. #BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  26. #WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  27. #OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  28. #EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  
  30. start_daemon () {
  31.     local force nice pidfile exec i
  32.     force=0
  33.     nice=0
  34.     pidfile=/dev/null
  35.  
  36.     OPTIND=1
  37.     while getopts fn:p: opt ; do
  38.         case "$opt" in
  39.             f)  force=1;;
  40.             n)  nice="$OPTARG";;
  41.             p)  pidfile="$OPTARG";;
  42.         esac
  43.     done
  44.     
  45.     shift $(($OPTIND - 1))
  46.     if [ "$1" = '--' ]; then
  47.         shift
  48.     fi
  49.  
  50.     exec="$1"; shift
  51.  
  52.     if [ $force = 1 ]; then
  53.         /sbin/start-stop-daemon --start --nicelevel $nice --quiet --startas $exec --pidfile /dev/null --oknodo -- "$@"
  54.     elif [ $pidfile ]; then
  55.         /sbin/start-stop-daemon --start --nicelevel $nice --quiet --exec $exec --oknodo --pidfile "$pidfile" -- "$@"
  56.     else
  57.         /sbin/start-stop-daemon --start --nicelevel $nice --quiet --exec $exec --oknodo -- "$@"
  58.     fi
  59. }
  60.  
  61. pidofproc () {
  62.     local pidfile line i pids= status specified pid
  63.     pidfile=
  64.     specified=
  65.     
  66.     OPTIND=1
  67.     while getopts p: opt ; do
  68.         case "$opt" in
  69.             p)  pidfile="$OPTARG"; specified=1;;
  70.         esac
  71.     done
  72.     shift $(($OPTIND - 1))
  73.  
  74.     if [ -z "${pidfile:-}" ]; then
  75.         pidfile=/var/run/${1##*/}.pid
  76.     fi
  77.  
  78.     if [ -f "$pidfile" ]; then
  79.         read pid < "$pidfile"
  80.         if [ -n "${pid:-}" ]; then
  81.             if $(kill -0 "${pid:-}" 2> /dev/null); then
  82.                 echo "$pid"
  83.                 return 0
  84.             elif ps "${pid:-}" >/dev/null 2>&1; then
  85.                 echo "$pid"
  86.                 return 0 # program is running, but not owned by this user
  87.             else
  88.                 return 1 # program is dead and /var/run pid file exists
  89.             fi
  90.         fi
  91.     fi
  92.     if [ -x /bin/pidof -a ! "$specified" ]; then
  93.         status="0"
  94.         /bin/pidof -o %PPID $1 || status="$?"
  95.         if [ "$status" = 1 ]; then
  96.             return 3 # program is not running
  97.         fi
  98.         return 0
  99.     fi
  100.     return 4 # program or service is unknown
  101. }
  102.  
  103. # start-stop-daemon uses the same algorithm as "pidofproc" above.
  104. killproc () {
  105.     local pidfile sig status base i name_param is_term_sig
  106.     pidfile=
  107.     name_param=
  108.     is_term_sig=no
  109.  
  110.     OPTIND=1
  111.     while getopts p: opt ; do
  112.         case "$opt" in
  113.             p)  pidfile="$OPTARG";;
  114.         esac
  115.     done
  116.     shift $(($OPTIND - 1))
  117.  
  118.     base=${1##*/}
  119.     if [ ! $pidfile ]; then
  120.         pidfile=/var/run/$base.pid
  121.         name_param="--name $base"
  122.     fi
  123.  
  124.     sig=$(echo ${2:-} | sed -e 's/^-\(.*\)/\1/')
  125.     sig=$(echo $sig | sed -e 's/^SIG\(.*\)/\1/')
  126.     if [ -z "$sig" -o "$sig" = 15 -o "$sig" = TERM ]; then
  127.         is_term_sig=yes
  128.     fi
  129.     status=0
  130.     if [ ! "$is_term_sig" = yes ]; then
  131.         if [ -n "$sig" ]; then
  132.             /sbin/start-stop-daemon --stop --signal "$sig" --pidfile "$pidfile" --quiet $name_param || status="$?"
  133.         else
  134.             /sbin/start-stop-daemon --stop --pidfile "$pidfile" --quiet $name_param || status="$?"
  135.         fi
  136.     else
  137.         /sbin/start-stop-daemon --stop --pidfile "$pidfile" --retry 5 --quiet --oknodo $name_param || status="$?"
  138.     fi
  139.     if [ "$status" = 1 ]; then
  140.         if [ -n "$sig" ]; then
  141.             return 0
  142.         fi
  143.         return 3 # program is not running
  144.     fi
  145.  
  146.     if [ "$status" = 0 -a "$is_term_sig" = yes ]; then
  147.         pidofproc -p $pidfile "$1" >/dev/null || rm -f "$pidfile"
  148.     fi
  149.     return 0
  150. }
  151.  
  152. # Return LSB status
  153. status_of_proc () {
  154.     local pidfile daemon name status
  155.  
  156.     pidfile=
  157.     OPTIND=1
  158.     while getopts p: opt ; do
  159.         case "$opt" in
  160.             p)  pidfile="$OPTARG";;
  161.         esac
  162.     done
  163.     shift $(($OPTIND - 1))
  164.  
  165.     if [ -n "$pidfile" ]; then
  166.         pidfile="-p $pidfile"
  167.     fi
  168.     daemon="$1"
  169.     name="$2"
  170.  
  171.     status="0"
  172.     pidofproc $pidfile $daemon >/dev/null || status="$?"
  173.     if [ "$status" = 0 ]; then
  174.         log_success_msg "$name is running."
  175.         return 0
  176.     else
  177.         log_failure_msg "$name is not running."
  178.         return $status
  179.     fi
  180. }
  181.  
  182. log_use_fancy_output () {
  183.     TPUT=/usr/bin/tput
  184.     EXPR=/usr/bin/expr
  185.     if [ -t 1 ] && [ "x$TERM" != "" ] && [ "x$TERM" != "xdumb" ] && [ -x $TPUT ] && [ -x $EXPR ] && $TPUT hpa 60 >/dev/null 2>&1 && $TPUT setaf 1 >/dev/null 2>&1; then
  186.         [ -z $FANCYTTY ] && FANCYTTY=1 || true
  187.     else
  188.         FANCYTTY=0
  189.     fi
  190.     case "$FANCYTTY" in
  191.         1|Y|yes|true)   true;;
  192.         *)              false;;
  193.     esac
  194. }
  195.  
  196. log_success_msg () {
  197.     echo "$@"
  198. }
  199.  
  200. log_failure_msg () {
  201.     if log_use_fancy_output; then
  202.         RED=`$TPUT setaf 1`
  203.         NORMAL=`$TPUT op`
  204.         /bin/echo -e "${RED}*${NORMAL} $@"
  205.     else
  206.         echo "$@"
  207.     fi
  208. }
  209.  
  210. log_warning_msg () {
  211.     if log_use_fancy_output; then
  212.         YELLOW=`$TPUT setaf 3`
  213.         NORMAL=`$TPUT op`
  214.         /bin/echo -e "${YELLOW}*${NORMAL} $@"
  215.     else
  216.         echo "$@"
  217.     fi
  218. }
  219.  
  220. #
  221. # NON-LSB HELPER FUNCTIONS
  222. #
  223. # int get_lsb_header_val (char *scriptpathname, char *key)
  224. get_lsb_header_val () {
  225.         if [ ! -f "$1" ] || [ -z "${2:-}" ]; then
  226.                 return 1
  227.         fi
  228.         LSB_S="### BEGIN INIT INFO"
  229.         LSB_E="### END INIT INFO"
  230.         sed -n "/$LSB_S/,/$LSB_E/ s/# $2: \(.*\)/\1/p" $1
  231. }
  232.  
  233. # int log_begin_message (char *message)
  234. log_begin_msg () {
  235.     if [ -z "${1:-}" ]; then
  236.         return 1
  237.     fi
  238.     echo -n "$@"
  239. }
  240.  
  241. # Sample usage:
  242. # log_daemon_msg "Starting GNOME Login Manager" "gdm"
  243. #
  244. # On Debian, would output "Starting GNOME Login Manager: gdm"
  245. # On Ubuntu, would output " * Starting GNOME Login Manager..."
  246. #
  247. # If the second argument is omitted, logging suitable for use with
  248. # log_progress_msg() is used:
  249. #
  250. # log_daemon_msg "Starting remote filesystem services"
  251. #
  252. # On Debian, would output "Starting remote filesystem services:"
  253. # On Ubuntu, would output " * Starting remote filesystem services..."
  254.  
  255. log_daemon_msg () {
  256.     if [ -z "${1:-}" ]; then
  257.         return 1
  258.     fi
  259.     log_daemon_msg_pre "$@"
  260.  
  261.     if [ -z "${2:-}" ]; then
  262.         echo -n "$1:"
  263.         return
  264.     fi
  265.     
  266.     echo -n "$1: $2"
  267.     log_daemon_msg_post "$@"
  268. }
  269.  
  270. # #319739
  271. #
  272. # Per policy docs:
  273. #
  274. #     log_daemon_msg "Starting remote file system services"
  275. #     log_progress_msg "nfsd"; start-stop-daemon --start --quiet nfsd
  276. #     log_progress_msg "mountd"; start-stop-daemon --start --quiet mountd
  277. #     log_progress_msg "ugidd"; start-stop-daemon --start --quiet ugidd
  278. #     log_end_msg 0
  279. #
  280. # You could also do something fancy with log_end_msg here based on the
  281. # return values of start-stop-daemon; this is left as an exercise for
  282. # the reader...
  283. #
  284. # On Ubuntu, one would expect log_progress_msg to be a no-op.
  285. log_progress_msg () {
  286.     if [ -z "${1:-}" ]; then
  287.         return 1
  288.     fi
  289.     echo -n " $@"
  290. }
  291.  
  292.  
  293. # int log_end_message (int exitstatus)
  294. log_end_msg () {
  295.     # If no arguments were passed, return
  296.     if [ -z "${1:-}" ]; then
  297.         return 1
  298.     fi
  299.     log_end_msg_pre "$@"
  300.  
  301.     # Only do the fancy stuff if we have an appropriate terminal
  302.     # and if /usr is already mounted
  303.     if log_use_fancy_output; then
  304.         RED=`$TPUT setaf 1`
  305.         NORMAL=`$TPUT op`
  306.         if [ $1 -eq 0 ]; then
  307.             echo "."
  308.         else
  309.             /bin/echo -e " ${RED}failed!${NORMAL}"
  310.         fi
  311.     else
  312.     if [ $1 -eq 0 ]; then
  313.             echo "."
  314.         else
  315.             echo " failed!"
  316.         fi
  317.     fi
  318.     log_end_msg_post "$@"
  319.     return $1
  320. }
  321.  
  322. log_action_msg () {
  323.     echo "$@."
  324. }
  325.  
  326. log_action_begin_msg () {
  327.     echo -n "$@..."
  328. }
  329.  
  330. log_action_cont_msg () {
  331.     echo -n "$@..."
  332. }
  333.  
  334. log_action_end_msg () {
  335.     log_action_end_msg_pre "$@"
  336.     if [ -z "${2:-}" ]; then
  337.         end="."
  338.     else
  339.         end=" ($2)."
  340.     fi
  341.  
  342.     if [ $1 -eq 0 ]; then
  343.         echo "done${end}"
  344.     else
  345.         if log_use_fancy_output; then
  346.             RED=`$TPUT setaf 1`
  347.             NORMAL=`$TPUT op`
  348.             /bin/echo -e "${RED}failed${end}${NORMAL}"
  349.         else
  350.             echo "failed${end}"
  351.         fi
  352.     fi
  353.     log_action_end_msg_post "$@"
  354. }
  355.  
  356. # Hooks for /etc/lsb-base-logging.sh
  357. log_daemon_msg_pre () { :; }
  358. log_daemon_msg_post () { :; }
  359. log_end_msg_pre () { :; }
  360. log_end_msg_post () { :; }
  361. log_action_end_msg_pre () { :; }
  362. log_action_end_msg_post () { :; }
  363.  
  364. FANCYTTY=
  365. [ -e /etc/lsb-base-logging.sh ] && . /etc/lsb-base-logging.sh || true
  366.